package com.twetec.cms.adapter.pc.backend.controller.website;

import cn.hutool.core.io.FileUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.twetec.cms.adapter.pc.backend.response.R;
import com.twetec.cms.adapter.pc.backend.response.ResultCodeMsgEnum;
import com.twetec.cms.common.constant.ColumnEnum;
import com.twetec.cms.common.util.validate.ValidateUtil;
import com.twetec.cms.model.po.system.CmsMenuPO;
import com.twetec.cms.model.po.system.CmsRoleMenuPO;
import com.twetec.cms.model.po.system.CmsUserRolePO;
import com.twetec.cms.model.po.user.UserPO;
import com.twetec.cms.model.po.website.ColumnPO;
import com.twetec.cms.model.po.website.SiteColumnPO;
import com.twetec.cms.model.po.website.SitePO;
import com.twetec.cms.model.vo.website.*;
import com.twetec.cms.service.system.CmsMenuService;
import com.twetec.cms.service.system.CmsRoleMenuService;
import com.twetec.cms.service.system.CmsUserRoleService;
import com.twetec.cms.service.ucenter.UserService;
import com.twetec.cms.service.website.ColumnService;
import com.twetec.cms.service.website.SiteColumnService;
import com.twetec.cms.service.website.SiteService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 站点栏目
 */
@Api(tags = "站点相关的栏目管理")
@RestController
@RequestMapping("/website/site-column")
public class SiteColumnController {

    private Logger logger = LoggerFactory.getLogger(SiteColumnController.class);

    @Autowired
    private SiteService siteService;

    @Autowired
    private SiteColumnService siteColumnService;

    @Autowired
    private ColumnService columnService;

    @Autowired
    private CmsUserRoleService cmsUserRoleService;

    @Autowired
    private CmsRoleMenuService cmsRoleMenuService;

    @Autowired
    private CmsMenuService cmsMenuService;

    @Autowired
    private StaticHtmlController staticHtmlController;

    @Value("${twetec.resource.preview-root-path}")
    private String rootPath;


    @ApiOperation(value = "站点栏目树")
    @GetMapping("/tree")
    public R<SiteColumnListVO> tree(@RequestAttribute("userId") Long userId){
        // 0、用于封装站点和其对应的栏目树的集合
        SiteColumnListVO siteColumnListVO = new SiteColumnListVO();
        ArrayList<SiteColumnTreeVO> siteCloumnTreeVOList = new ArrayList<>();

        // 0.1、先查询用户的对应的角色
        // 获取用户对应的角色ID
        QueryWrapper<CmsUserRolePO> cmsUserRolePOQueryWrapper = new QueryWrapper<>();
        cmsUserRolePOQueryWrapper.lambda().eq(CmsUserRolePO::getUserId, userId);
        List<CmsUserRolePO> cmsUserRolePOS = cmsUserRoleService.list(cmsUserRolePOQueryWrapper);
        if (null == cmsUserRolePOS) {
            siteColumnListVO.setList(siteCloumnTreeVOList);
            return R.success().data(siteColumnListVO);
        }

        // 获取用户对应的角色id集合
        ArrayList<Long> roleIds = new ArrayList<>();
        for (CmsUserRolePO cmsUserRolePO : cmsUserRolePOS) {
            roleIds.add(cmsUserRolePO.getRoleId());
        }

        // 0.2、角色对应的权限菜单

        // 0.3、获取站点id、栏目id集合
//        cmsMenuColumnPO.getType    ZHAN_DIAN,LAN_MU
        // 站点id的集合
//        QueryWrapper cmsMenuPOQueryWrapper = new QueryWrapper<>();
//        cmsMenuPOQueryWrapper.eq("CMS_MENU.TYPE", "ZHAN_DIAN");
//        cmsMenuPOQueryWrapper.in("CMS_ROLE_MENU.ROLE_ID", roleIds);
        List<CmsMenuPO> cmsMenuSitePOList = cmsMenuService.getAllRolePermission(roleIds, "ZHAN_DIAN");
        ArrayList<Long> siteMenuIdList = new ArrayList<>();
        cmsMenuSitePOList.forEach(cmsMenuPO -> {
            siteMenuIdList.add(cmsMenuPO.getSiteId());
        });
        // 栏目id的集合
//        QueryWrapper<CmsMenuPO> cmsMenuColumnQueryWrapper = new QueryWrapper<>();
//        cmsMenuColumnQueryWrapper.eq("CMS_MENU.TYPE", "LAN_MU");
//        cmsMenuColumnQueryWrapper.in("CMS_ROLE_MENU.ROLE_ID", roleIds);
        List<CmsMenuPO> cmsMenuColumnPOList = cmsMenuService.getAllRolePermission(roleIds, "LAN_MU");
        ArrayList<Long> columnMenuIdList = new ArrayList<>();
        cmsMenuColumnPOList.forEach(cmsMenuPO -> columnMenuIdList.add(cmsMenuPO.getColumnId()));


        // 1、获取所有的站点信息，并遍历
        QueryWrapper<SitePO> siteWrapper = new QueryWrapper<>();
        siteWrapper.eq("IS_RECOVERY", 0);
        siteWrapper.orderByDesc("SORT");
        siteWrapper.orderByAsc("ID");
        List<SitePO> sitePOList = siteService.list(siteWrapper);

        // 2、根据站点信息获取站点下的顶级栏目ID
        // 遍历获取到的站点
        for (SitePO sitePO : sitePOList) {

            // 如果权限中没有此站点，就跳过
            if (!siteMenuIdList.contains(sitePO.getId())) continue;

            // 先将站点信息存入siteCloumnTreeVO中
            SiteColumnTreeVO siteSiteCloumnTreeVO = new SiteColumnTreeVO();
            BeanUtils.copyProperties(sitePO, siteSiteCloumnTreeVO);
            siteSiteCloumnTreeVO.setType(0);


            // 通过一个站点Id获取中间表中所有对应的顶级栏目ID
            QueryWrapper<SiteColumnPO> siteColumnWrapper = new QueryWrapper<>();
            siteColumnWrapper.eq("SITE_ID", sitePO.getId());
            List<SiteColumnPO> siteColumnlist = siteColumnService.list(siteColumnWrapper);

            // 用于存储每一个顶级栏目对应的树
            ArrayList<SiteColumnTreeVO> rootColumnSiteCloumnTreeVOList = new ArrayList<>();

            // 提取出站点对应的顶级栏目的id，并添加到集合
            // 只有不为空才进行查询查询
            if (!ValidateUtil.isNullOrEmpty(siteColumnlist)) {
                ArrayList<Long> columnIdList = new ArrayList<>();
                for (SiteColumnPO siteColumnPO : siteColumnlist) {
                    // 权限中有的栏目才加入集合
                    if (columnMenuIdList.contains(siteColumnPO.getColumnId())) {
                        columnIdList.add(siteColumnPO.getColumnId());
                    }
                }
                // 再通过集合到栏目表中去查询，以达到排序的目的
                QueryWrapper<ColumnPO> columnTempWrapper = new QueryWrapper<>();
                columnTempWrapper.in("ID", columnIdList);
                columnTempWrapper.eq("IS_RECOVERY", 0);
                columnTempWrapper.orderByDesc("SORT");
                columnTempWrapper.orderByAsc("ID");
                List<ColumnPO> columnPOList = columnService.list(columnTempWrapper);


                // 如果站点下没有栏目设置栏目树childList为空
                if (!ValidateUtil.isNullOrEmpty(columnPOList)) {


                    // 遍历一个站点对应的所有顶级栏目
                    for (ColumnPO rootColumnPO : columnPOList) {

                   /* // 3、根据顶级栏目ID获取对应顶级栏目信息
                    QueryWrapper<ColumnPO> columnWrapper = new QueryWrapper<>();
                    columnWrapper.eq("IS_RECOVERY", 0);
                    columnWrapper.eq("ID", siteColumnPO.getColumnId());
                    ColumnPO rootColumnPO = columnService.getOne(columnWrapper);*/

                        if (rootColumnPO != null) {
                            // 4、通过顶级栏目获取所有对应子栏目
                            QueryWrapper<ColumnPO> childColumnWrapper = new QueryWrapper<>();
                            childColumnWrapper.likeRight("XPATH", rootColumnPO.getXpath() + "-" + rootColumnPO.getId());
                            childColumnWrapper.eq("IS_RECOVERY", 0);
                            childColumnWrapper.orderByDesc("SORT");
                            childColumnWrapper.orderByAsc("ID");

                            List<ColumnPO> allChildColumnPOList = columnService.list(childColumnWrapper);

                            List<ColumnPO> allChildColumnPOMenuList = new ArrayList<>();
                            // 要有权限的才行
                            for (ColumnPO columnPO : allChildColumnPOList) {
                                if (columnMenuIdList.contains(columnPO.getId())) {
                                    allChildColumnPOMenuList.add(columnPO);
                                }
                            }

                            // 5、将顶级栏目对象和该栏目下面的所有有权限的子栏目的集合放入递归方法中，返回的树整理好的顶级栏目树。
                            SiteColumnTreeVO columnSiteCloumnTreeVO = p_arrangeColumnTree(rootColumnPO, allChildColumnPOMenuList);

                            // 6、将一个顶级栏目的树放入存放所有树的集合中，遍历完后，就获得了该顶级栏目下所有的栏目树
                            rootColumnSiteCloumnTreeVOList.add(columnSiteCloumnTreeVO);
                        }

                    }
                }
            }
            // 将一个站点对应的所有栏目树放入站点中
            siteSiteCloumnTreeVO.setChildList(rootColumnSiteCloumnTreeVOList);

            // 将一个站点栏目树放入栏目树集合中
            siteCloumnTreeVOList.add(siteSiteCloumnTreeVO);
        }
        // 将所有的栏目树封装到返回对象中

        siteColumnListVO.setList(siteCloumnTreeVOList);

        return R.success().data(siteColumnListVO);
    }

    /**
     * 整理一个栏目下的树形栏目结构
     * @param parentPOColumn 父栏目
     * @param allChildColumnPOList 子栏目的集合
     * @return
     */
    private SiteColumnTreeVO p_arrangeColumnTree(ColumnPO parentPOColumn, List<ColumnPO> allChildColumnPOList) {

        // 先将当前栏目转换为SiteCloumnTreeVO
        SiteColumnTreeVO parentSiteCloumnTreeVO = new SiteColumnTreeVO();
        BeanUtils.copyProperties(parentPOColumn, parentSiteCloumnTreeVO);
        parentSiteCloumnTreeVO.setType(1);

        // 创建一个集合用于放置子对象
        List<SiteColumnTreeVO> childColumnVOList = new ArrayList<>();


        // 遍历子栏目集合
        for (ColumnPO columnPO : allChildColumnPOList) {

            // 将子栏目的ParentID 与父栏目的ID进行对比，找到直接子栏目
            if (columnPO.getParentId().equals(parentPOColumn.getId())) {

                // 比较一次的情况下，下级栏目的父id和上级栏目的id相同的话就添加到子栏目的集合中去
                // childColumnVOList.add(columnVO);

                // 调用方法放入当前下级栏目和子栏目集合，如果当前栏目没有子栏目那么就返回一个空的集合
                // 而如果当前下级栏目有子栏目，那么就会继续查找当前下级栏目的子栏目的子栏目。
                // 返回的结果就是当前子栏目下的子栏目树
                SiteColumnTreeVO childSiteCloumnTreeVO = p_arrangeColumnTree(columnPO, allChildColumnPOList);

                //将子栏目树放入到集合中
                childColumnVOList.add(childSiteCloumnTreeVO);
            }
        }
        // 设置父栏目的子栏目树
        parentSiteCloumnTreeVO.setChildList(childColumnVOList);

        return parentSiteCloumnTreeVO;
    }


    @ApiOperation(value = "根据站点id获取当前站点下的栏目树")
    @GetMapping("/get-column-tree-by-site-id")
    public R<SiteColumnListVO> getColumnTreeBySiteId(@ApiParam(value = "站点id", required = true, example = "123456789") @RequestParam(required = true) Long siteId) {
        // 校验siteId
        if (siteId == null || !ValidateUtil.Number(siteId) || siteId <= 0) return R.failureRequestParam().msg("站点id不能为空");

        ArrayList<SiteColumnTreeVO> siteColumnTreeVOList = new ArrayList<>();
        // 返回的VO对象
        SiteColumnListVO siteColumnListVO = new SiteColumnListVO();

        // 查询站点信息
        SitePO sitePO = siteService.getById(siteId);

        SiteColumnTreeVO siteColumnTreeVO = new SiteColumnTreeVO();
        if (sitePO == null) {
            return R.failure().msg("站点不存在");
        }
        siteColumnTreeVO.setId(siteId);
        siteColumnTreeVO.setType(0);
        siteColumnTreeVO.setName(sitePO.getName());

        // 根据站点信息获取其下的顶级栏目id集合
        QueryWrapper<SiteColumnPO> siteColumnPOQueryWrapper = new QueryWrapper<>();
        siteColumnPOQueryWrapper.eq("SITE_ID", siteId);
        siteColumnPOQueryWrapper.orderByAsc("COLUMN_ID");
        List<SiteColumnPO> siteColumnPOList = siteColumnService.list(siteColumnPOQueryWrapper);


        // 存储每一个顶级栏目下的树
        ArrayList<SiteColumnTreeVO> rootColumnSiteCloumnTreeVOList = new ArrayList<>();

        // 判断如果集合为空就返回一个空树
        if (siteColumnPOList == null || siteColumnPOList.isEmpty()) {
            // 返回一个空树
            siteColumnListVO.setList(new ArrayList<>());
        } else {
            // 遍历集合
            for (SiteColumnPO siteColumnPO : siteColumnPOList) {

                // 根据顶级栏目id获取顶级栏目的信息
                QueryWrapper<ColumnPO> columnWrapper = new QueryWrapper<>();
                columnWrapper.eq("IS_RECOVERY", 0);
                columnWrapper.eq("ID", siteColumnPO.getColumnId());
                columnWrapper.orderByDesc("SORT");
                columnWrapper.orderByAsc("ID");
                ColumnPO rootColumnPO = columnService.getOne(columnWrapper);

                // 判断是否查询到顶级栏目信息
                if (rootColumnPO != null) {
                    // 通过顶级栏目获取对应的子栏目集合
                    QueryWrapper<ColumnPO> childColumnWrapper = new QueryWrapper<>();
                    childColumnWrapper.likeRight("XPATH", rootColumnPO.getXpath() + "-" + rootColumnPO.getId());
                    childColumnWrapper.eq("IS_RECOVERY", 0);
                    childColumnWrapper.orderByDesc("SORT");
                    childColumnWrapper.orderByAsc("ID");
                    List<ColumnPO> allChildColumnPOList = columnService.list(childColumnWrapper);

                    // 将顶级栏目对象和该栏目下面的所有子栏目的集合放入递归方法中，返回的树整理好的顶级栏目树
                    SiteColumnTreeVO columnSiteCloumnTreeVO = p_arrangeColumnTree(rootColumnPO, allChildColumnPOList);
                    // 将顶级栏目树放入集合中
                    rootColumnSiteCloumnTreeVOList.add(columnSiteCloumnTreeVO);
                }
            }
            siteColumnTreeVO.setChildList(rootColumnSiteCloumnTreeVOList);
        }
        siteColumnTreeVOList.add(siteColumnTreeVO);

        siteColumnListVO.setList(siteColumnTreeVOList);

        return R.success().data(siteColumnListVO);

    }


}
